Semantic jargon

ABSTRACT

Configuring computer memory including parsing digitized speech into a triples of a description logic; determining whether parsed triples are recorded in a general language triple store of the computer memory; determining whether parsed triples are recorded in a jargon triple store of the computer memory; and, if the parsed triples are recorded in neither the general language triple store nor the jargon triple store, recording the parsed triples in the jargon triple store.

BACKGROUND

The development of the EDVAC computer system of 1948 is often cited as the beginning of the computer era. Since that time, computer systems have evolved into complicated devices. These complicated devices include complicated computer memory. Methods and systems for efficient use of computer memory continue to evolve.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 sets forth a network diagram illustrating an example system for configuring computer memory according to embodiments of the present invention.

FIG. 2 sets forth a line drawing of a graph of semantic triples.

FIG. 3 sets forth a functional block diagram of example apparatus for configuring computer memory in a thin-client architecture according to embodiments of the present invention.

FIG. 4 sets forth a block diagram of automated computing machinery comprising an example of a computer useful as a voice server for configuring computer memory of a speech-enabled device according to embodiments of the present invention.

FIG. 5 sets forth a block diagram of automated computing machinery comprising an example of a computer useful as a triple server for configuring computer memory according to embodiments of the present invention.

FIG. 6 sets forth a block diagram of a computer memory system.

FIG. 7 sets forth a functional block diagram of example apparatus for configuring computer memory in a thick-client architecture according to embodiments of the present invention.

FIG. 8 sets forth a flow chart illustrating an example method of configuring computer memory according to embodiments of the present invention.

FIG. 9 sets forth a graph of a language-specific triple store in which a general language triple store and two jargon triple stores are logically-connected segments of a same overall graph.

FIG. 10 sets forth separate graphs of a general language triple store, a medical jargon in English, and a legal jargon in English.

FIG. 11 sets forth a flow chart illustrating a further example method of configuring computer memory according to embodiments of the present invention.

FIG. 12 sets forth a flow chart illustrating a further example method of configuring computer memory according to embodiments of the present invention.

DETAILED DESCRIPTION OF EXAMPLE EMBODIMENTS

Example methods, apparatus, and products for configuring computer memory are described with reference to the accompanying drawings, beginning with FIG. 1. FIG. 1 sets forth a network diagram illustrating an example system for configuring computer memory according to embodiments of the present invention. Configuring computer memory in the example of FIG. 1 is implemented with at least one speech-enabled device (152), a triple server (157), and a voice server (151). A speech-enabled device is automated computing machinery configured to accept and recognize speech from a user and express to a user voice prompts and speech responses. Speech-enabled devices in the example of FIG. 1 include a desktop computer (107), a smartwatch (112), a mobile phone (110), and a laptop computer (126). Each speech-enabled device in this example is coupled for data communications through network (100) to the triple server (157) and the voice server (151). The desktop computer is connected through wireline connection (120), while the smartwatch (112), mobile phone (110), and laptop (126) are connected respectively through wireless connections (114, 116, 118).

The overall example computer system illustrated in FIG. 1 operates generally to configure computer memory (169) according to embodiments of the present invention by parsing a word (509) of digitized speech (508) from a conversation (313) into a triple (752) of a description logic. Computer memory includes cache, random access memory (“RAM”), disk storage, and so on, most forms of computer memory. Computer memory so configured typically resides upon speech-enabled devices, or, as shown here (169), upon one or more triple servers (157). The overall example system of FIG. 1 also operates generally to determine whether the parsed triple (752) is recorded in a general language triple store (323), determine whether the parsed triple is recorded in a jargon triple store (325), and, if the parsed triple is recorded in neither the general language triple store nor the jargon triple store, record the parsed triple in the jargon triple store. The general language triple store (323) is composed of structured definitions of words not special to any particular knowledge domain, where each structured definition of the general language store is implemented with a triple of description logic. In a similar fashion, the jargon triple store (325) is composed of structured definitions of words that are special to a particular knowledge domain, where each structured definition of the jargon triple store is implemented with a triple of description logic.

The word (509) of digitized speech (508) is speech for recognition (315) from a conversation (313). The speech for recognition can be the entire conversation, where, for example, both persons speaking are in the same room, and the entire conversation is picked up by a microphone on a speech-enabled device. The scope of speech for recognition can be reduced by providing to a speech-enabled device only one side of the conversation, as only through a microphone on a headset (105). The scope of speech for recognition can be reduced even further by providing for recognition only speech that responds to a prompt from a VoiceXML dialogue executing on a speech-enabled device. As the scope of speech for recognition is reduced, data processing burdens are reduced across the system as a whole, although it remains an option, in some embodiments at least, to recognize the entire conversation and stream across a display (110) a flow of all words in the conversation.

Speech from the conversation (313) is recognized into digitized speech by operation of a natural language processing speech recognition (“NLP-SR”) engine (153), shown here disposed upon a voice server (151), but also amenable to installation on speech-enabled devices. The NLP-SR engine also carries out the parsing of a word (509) of the speech so digitized (508) into a triple (752) of a description logic.

A triple is a three-part statement expressed in a form of logic. Depending on context, different terminologies are used to refer to effectively the same three parts of a statement in a logic. In first order logic, the parts are called constant, unary predicate, and binary predicate. In the Web Ontology Language (“OWL”) the parts are individual, class, and property. In some description logics the parts are called individual, concept, and role.

In this paper, the elements of a triple are referred to as subject, predicate, and object—and expressed like this: <subject> <predicate> <object>. There are many modes of expression for triples. Elements of triples can be represented as Uniform Resource Locaters (“URLs”), Uniform Resource Identifiers (“URIs”), or International Resource Identifiers (“IRIs”). Triples can be expressed in N-Quads, Turtle syntax, TriG, Javascript Object Notation or “JSON,” the list goes on and on. The expression used here, subject-predicate-object in angle brackets, is one form of abstract syntax, optimized for human readability rather than machine processing, although its substantive content is correct for expression of triples. Using this abstract syntax, here are examples of triples:

<Bob> <is a> <person> <Bob> <is a friend of> <Alice> <Bob> <is born on> <the 4^(th) of July 1990> <Bob> <is interested in> <the Mona Lisa> <the Mona Lisa> <was created by> <Leonardo da Vinci> <the video ‘La Joconde à Washington’> <is about> <the Mona Lisa>

The same item can be referenced in multiple triples. In this example, Bob is the subject of four triples, and the Mona Lisa is the subject of one triple and the object of two. This ability to have the same item be the subject of one triple and the object of another makes it possible to effect connections among triples, and connected triples form graphs.

For further explanation of relations among triples and graphs, FIG. 2 sets forth a line drawing of a graph (600). The example graph of FIG. 2 implements in graph form the example triples set forth above regarding Bob and the Mona Lisa. In the example of FIG. 2, the graph edges (604, 608, 612, 616, 620, 624) represent respectively relations among the node, that is, represent the predicates <is a>, <is a friend of>, <is born on>, <is interested in>, <was created by>, and <is about>. The nodes themselves represent the subjects and objects of the triples, <Bob>, <person>, <Alice>, <the 4^(th) of July 1990>, <the Mona Lisa>, <Leonardo da Vinci>, and <the video ‘La Joconde à Washington’>.

In systems of knowledge representation, knowledge represented in graphs of triples, including, for example, knowledge representations implemented in Prolog databases, Lisp data structures, or in RDF-oriented ontologies in RDFS, OWL, and other ontology languages. Search and inference are effected against such graphs by search engines configured to execute semantic queries in, for example, Prolog or SPARQL. Prolog is a general-purpose logic programming language. SPARQL is a recursive acronym for “SPARQL Protocol and RDF Query Language.” Prolog supports queries against connected triples expressed as statements and rules in a Prolog database. SPARQL supports queries against ontologies expressed in RDFS or OWL or other RDF-oriented ontologies. Regarding Prolog, SPARQL, RDF, and so on, these are examples of technologies explanatory of example embodiments of the present invention. Thus, such are not limitations of the present invention. Knowledge representations useful according to embodiments can take many forms as may occur to those of skill in the art, now or in the future, and all such are now and will continue to be well within the scope of the present invention.

A description logic is a member of a family of formal knowledge representation languages. Some description logics are more expressive than propositional logic but less expressive than first-order logic. In contrast to first-order logics, reasoning problems for description logics are usually decidable. Efficient decision procedures therefore can be implemented for problem of search and inference in description logics. There are general, spatial, temporal, spatiotemporal, and fuzzy descriptions logics, and each description logic features a different balance between expressivity and reasoning complexity by supporting different sets of mathematical constructors.

Search queries are disposed along a scale of semantics. A traditional web search, for example, is disposed upon a zero point of that scale, no semantics, no structure. A traditional web search against the keyword “derivative” returns HTML documents discussing the literary concept of derivative works as well as calculus procedures. A traditional web search against the keyword “differential” returns HTML pages describing automobile parts and calculus functions.

Other queries are disposed along mid-points of the scale, some semantics, some structure, not entirely complete. This is actually a current trend in web search. Such systems may be termed executable rather than decidable. From some points of view, decidability is not a primary concern. In many Web applications, for example, data sets are huge, and they simply do not require a 100 percent correct model to analyze data that may have been spidered, scraped, and converted into structure by some heuristic program that itself is imperfect. People use Google because it can find good answers a lot of the time, even if it cannot find perfect answers all the time. In such rough-and-tumble search environments, provable correctness is not a key goal.

Other classes of queries are disposed where correctness of results is key, and decidability enters. A user who is a tele-agent in a data center speaking by phone with an automotive customer discussing a front differential is concerned not to be required to sort through calculus results to find correct terminology. Such a user needs correct definitions of automotive terms, and the user needs query results in conversational real time, that is, for example, within seconds.

In formal logic, a system is decidable if there exists a method such that, for every assertion that can be expressed in terms of the system, the method is capable of deciding whether or not the assertion is valid within the system. In practical terms, a query against a decidable description logic will not loop indefinitely, crash, fail to return an answer, or return a wrong answer. A decidable description logic supports data models or ontologies that are clear, unambiguous, and machine-processable. Undecidable systems do not. A decidable description logic supports algorithms by which a computer system can determine equivalence of classes defined in the logic. Undecidable systems do not. Decidable description logics can be implemented in C, C++, SQL, Lisp, RDF/RDFS/OWL, and so on. In the RDF space, subdivisions of OWL vary in decidability. Full OWL does not support decidability. OWL DL does.

For further explanation, FIG. 3 sets forth a functional block diagram of example apparatus for configuring computer memory in a thin-client architecture according to embodiments of the present invention. A thin-client architecture is a client-server architecture in which at least some of, perhaps most of, perhaps all of, speech processing and triple processing is off-loaded from the client to servers. Thinness of a thin-client varies. The speech-enabled device in the example of FIG. 3 is a thin client in which most speech processing is off-loaded to a voice server (151). The speech-enabled device (152) accepts voice input (315, 174), but then transfers the voice input through a VOIP connection (216) to the voice server (151) where all speech processing is performed. The speech-enabled device in this example does implement some capacity for triple processing (323, 325) and query execution (298), but none of that would be absolutely necessary in a thin client. Devices with reduced storage capacity, a smartwatch or a mobile phone for example, can be implemented with no semantic query engine (298) and no triple store (323, 325), merely passing queries through to a triple server (157) that itself carries out all triple storage and all query processing.

In the particular example of FIG. 3, the speech-enabled device occupies the middle ground of thin-client architecture. It supports little speech processing, but it does support some triple processing. The speech-enabled device in this example performs triple processing and query execution only against triple stores in RAM (168), leaving large-scale storage to the triple server (157). The semantic query engine loads the triple stores as needed to respond to queries. Thus, there are query misses. When the semantic query engine cannot satisfy a query with the triple stores in RAM, it does not conclude failure. Instead it passes the query to the triple server, and, if the triple server can satisfy the query by use of triples on the server, it passes back to the speech-enabled device both the query results and the triples that satisfied the query, which triples are then stored in RAM on the speech-enabled device for use against similar queries in the future. Over time, such an architecture builds on the speech-enabled device query stores containing frequently useful triples and reduced the need for costly query trips across the network to the triple server—while at the same time functioning with a relatively thin layer of computing resources on the client side. This is a compromise between the extremely thin client with no triple storage at all and the thick client described below with regard to FIG. 5.

The example apparatus of FIG. 3 includes a speech-enabled device (152) and a voice server (151) connected for data communication by a VOIP connection (216) through a data communications network (100). A speech-enabled application (195) runs on the speech-enabled device (152). The speech-enabled application (195) may be implemented as a set or sequence of X+V or SALT documents that execute on a speech-enabled browser, a Java Voice application that executes on a Java Virtual Machine, or a speech-enabled application implemented in other technologies as may occur to those of skill in the art. The example speech-enabled device of FIG. 3 also includes a sound card (174), which is an example of an I/O adapter specially designed for accepting analog audio signals from a microphone (176) and converting the audio analog signals to digital form for further processing by a codec (183).

VOIP stands for ‘Voice Over Internet Protocol,’ a generic term for routing speech over an IP-based data communications network. The speech data flows over a general-purpose packet-switched data communications network, instead of traditional dedicated, circuit-switched voice transmission lines. Protocols used to carry voice signals over the IP data communications network are commonly referred to as ‘Voice over IP’ or ‘VOIP’ protocols. VOIP traffic may be deployed on any IP data communications network, including data communications networks lacking a connection to the rest of the Internet, for instance on a private building-wide local area data communications network or ‘LAN.’

Many protocols may be used to effect VOIP, including, for example, types of VOIP effected with the IETF's Session Initiation Protocol (‘SIP’) and the ITU's protocol known as ‘H.323.’ SIP clients use TCP and UDP port 5060 to connect to SIP servers. SIP itself is used to set up and tear down calls for speech transmission. VOIP with SIP then uses RTP for transmitting the actual encoded speech. Similarly, H.323 is an umbrella recommendation from the standards branch of the International Telecommunications Union that defines protocols to provide audio-visual communication sessions on any packet data communications network.

Speech-enabled application (195) is a user-level, speech-enabled, client-side computer program that presents a voice interface to user (128), provides audio prompts and responses (314) and accepts input speech for recognition (315). Speech-enabled application (195) provides a speech interface through which a user may provide oral speech for recognition through microphone (176) and have the speech digitized through an audio amplifier (185) and a coder/decoder (‘codec’) (183) of a sound card (174) and provide the digitized speech for recognition to a voice server (151). Speech-enabled application (195) packages digitized speech in recognition request messages according to a VOIP protocol, and transmits the speech to voice server (151) through the VOIP connection (216) on the network (100).

Voice server (151) provides voice recognition services for speech-enabled devices by accepting dialog instructions, VoiceXML segments, or the like, and returning speech recognition results, including text representing recognized speech, text for use as variable values in dialogs, and output from execution of semantic interpretation scripts as well as voice prompts. Voice server (151) includes computer programs that provide text-to-speech (‘TTS’) conversion for voice prompts and voice responses to user input in speech-enabled applications such as, for example, X+V applications, SALT applications, or Java Speech applications.

The speech-enabled device (152) in the example of FIG. 3 includes a semantic query engine (298), a module of automated computing machinery that accepts from the speech-enabled application (195) and executes against triple stores (323, 325) semantic queries (340). The speech-enabled application (195) formulates semantic queries with user input from speech (315), GUI, keyboard, mouse (180, 181), or the like. A semantic query is a query designed and implemented against structured data. Semantic queries utilize logical operators, namespaces, pattern matching, subclassing, transitive relations, semantic rules and contextual full text search. Semantic queries work on named graphs, linked-data, or triples. In embodiments of the present invention, triples typically are linked so as to form graphs. This enables a semantic query to process actual relationships between items of information and infer answers from the network of data. Semantic queries contrast with semantic search, which attempts with various levels of success to use semantics in unstructured text to improve meaning of search results.

Example formulations of semantic queries are had in C, C++, Java, Prolog, Lisp, and so on. The semantic web technology stack of the W3C, for example, offers SPARQL to formulate semantic queries in a syntax similar to SQL. Semantic queries are used against data structured in triple stores, graph databases, semantic wikis, natural language, and artificial intelligence systems. As mentioned, semantic queries work on structured data, and in the particular examples of the present case, the structured data is words described and defined in semantic triples connected in ways that conform to a description logic. In many embodiments of the present invention, semantic queries are asserted against data structured according to a description logic that implements decidability.

In the example apparatus of FIG. 3, the speech-enabled device is coupled for data communication through a communications adapter (167), wireless connection (118), data communications network (100), and wireline connection (121) to a triple server (157). The triple server (157) provides large volume backup for triple stores (323, 325). The triple server is a configuration of automated computing machinery that serializes triples and stores serialized triples in relational databases, tables, files, or the like. The triple server retrieves upon request from non-volatile storage such serialized triples, parses the serialized triples into triple stores, and provides such triple stores upon request to speech-enabled devices for use in systems that utilize the triples in configuring computer memory according to embodiments of the present invention.

Configuring computer memory with triples of description logic according to embodiments of the present invention, particularly in a thin-client architecture, may be implemented with one or more voice servers. A voice server is a computer, that is, automated computing machinery, that provides speech recognition and speech synthesis. For further explanation, therefore, FIG. 4 sets forth a block diagram of automated computing machinery comprising an example of a computer useful as a voice server (151) for configuring computer memory of a speech-enabled device according to embodiments of the present invention. The voice server (151) of FIG. 2 includes at least one computer processor (156) or ‘CPU’ as well as random access memory (168) (‘RAM’) which is connected through a high-speed memory bus (166) and bus adapter (158) to processor (156) and to other components of the voice server.

Stored in RAM (168) is a voice server application (188), a module of computer program instructions capable of operating a voice server in a system that is configured for use in configuring memory according to embodiments of the present invention. Voice server application (188) provides voice recognition services for multimodal devices by accepting requests for speech recognition and returning speech recognition results, including text representing recognized speech, text for use as variable values in dialogs, and text as string representations of scripts for semantic interpretation. Voice server application (188) also includes computer program instructions that provide text-to-speech (‘TTS’) conversion for voice prompts and voice responses to user input in speech-enabled applications such as, for example, speech-enabled browsers, X+V applications, SALT applications, or Java Speech applications, and so on.

Voice server application (188) may be implemented as a web server, implemented in Java, C++, Python, Perl, or any language that supports X+V, SALT, VoiceXML, or other speech-enabled languages, by providing responses to HTTP requests from X+V clients, SALT clients, Java Speech clients, or other speech-enabled client devices. Voice server application (188) may, for a further example, be implemented as a Java server that runs on a Java Virtual Machine (102) and supports a Java voice framework by providing responses to HTTP requests from Java client applications running on speech-enabled devices. And voice server applications that support embodiments of the present invention may be implemented in other ways as may occur to those of skill in the art, and all such ways are well within the scope of the present invention.

The voice server (151) in this example includes a natural language processing speech recognition (“NLP-SR”) engine (153). An NLP-SR engine is sometimes referred to in this paper simply as a ‘speech engine.’ A speech engine is a functional module, typically a software module, although it may include specialized hardware also, that does the work of recognizing and generating human speech. In this example, the speech engine (153) is a natural language processing speech engine that includes a natural language processing (“NLP”) engine (155). The NLP engine accepts recognized speech from an automated speech recognition (‘ASR’) engine, processes the recognized speech into parts of speech, subject, predicates, object, and so on, and then converts the recognized, processed parts of speech into semantic triples for inclusion in triple stores.

The speech engine (153) includes an automated speech recognition (‘ASR’) engine for speech recognition and a text-to-speech (‘TTS’) engine for generating speech. The speech engine also includes a grammar (104), a lexicon (106), and a language-specific acoustic model (108). The language-specific acoustic model (108) is a data structure, a table or database, for example, that associates speech feature vectors (‘SFVs’) with phonemes representing pronunciations of words in a human language. The lexicon (106) is an association of words in text form with phonemes representing pronunciations of each word; the lexicon effectively identifies words that are capable of recognition by an ASR engine. Also stored in RAM (168) is a Text-To-Speech (‘TTS’) Engine (194), a module of computer program instructions that accepts text as input and returns the same text in the form of digitally encoded speech, for use in providing speech as prompts for and responses to users of speech-enabled systems.

The grammar (104) communicates to the ASR engine (150) the words and sequences of words that currently may be recognized. For further explanation, distinguish the purpose of the grammar and the purpose of the lexicon. The lexicon associates with phonemes all the words that the ASR engine can recognize. The grammar communicates the words currently eligible for recognition. The two sets at any particular time may not be the same.

Grammars may be expressed in a number of formats supported by ASR engines, including, for example, the Java Speech Grammar Format (‘JSGF’), the format of the W3C Speech Recognition Grammar Specification (‘SRGS’), the Augmented Backus-Naur Format (‘ABNF’) from the IETF's RFC2234, in the form of a stochastic grammar as described in the W3C's Stochastic Language Models (N-Gram) Specification, and in other grammar formats as may occur to those of skill in the art. Grammars typically operate as elements of dialogs, such as, for example, a VoiceXML <menu> or an X+V <form>. A grammar's definition may be expressed in-line in a dialog. Or the grammar may be implemented externally in a separate grammar document and referenced from with a dialog with a URI. Here is an example of a grammar expressed in JSFG:

<grammar scope=“dialog” ><![CDATA[ #JSGF V1.0; grammar command; <command> = [remind me to] call | phone | telephone <name> <when>; <name> = bob | martha | joe | pete | chris | john | artoush; <when> = today | this afternoon | tomorrow | next week; ]]> </grammar>

In this example, the elements named <command>, <name>, and <when> are rules of the grammar. Rules are a combination of a rulename and an expansion of a rule that advises an ASR engine or a voice interpreter which words presently can be recognized. In this example, expansion includes conjunction and disjunction, and the vertical bars ‘|’ mean ‘or.’ An ASR engine or a voice interpreter processes the rules in sequence, first <command>, then <name>, then <when>. The <command> rule accepts for recognition ‘call’ or ‘phone’ or ‘telephone’ plus, that is, in conjunction with, whatever is returned from the <name> rule and the <when> rule. The <name>rule accepts ‘bob’ or ‘martha’ or ‘joe’ or ‘pete’ or ‘chris’ or ‘john’ or ‘artoush’, and the <when> rule accepts ‘today’ or ‘this afternoon’ or ‘tomorrow’ or ‘next week.’ The command grammar as a whole matches utterances like these, for example:

-   -   “phone bob next week,”     -   “telephone martha this afternoon,”     -   “remind me to call chris tomorrow,” and     -   “remind me to phone pete today.”

The voice server application (188) in this example is configured to receive, from a speech-enabled client device located remotely across a network from the voice server, digitized speech for recognition from a user and pass the speech along to the ASR engine (150) for recognition. ASR engine (150) is a module of computer program instructions, also stored in RAM in this example. In carrying out automated speech recognition, the ASR engine receives speech for recognition in the form of at least one digitized word and uses frequency components of the digitized word to derive a speech feature vector or SFV. An SFV may be defined, for example, by the first twelve or thirteen Fourier or frequency domain components of a sample of digitized speech. The ASR engine can use the SFV to infer phonemes for the word from the language-specific acoustic model (108). The ASR engine then uses the phonemes to find the word in the lexicon (106).

Also stored in RAM is a VoiceXML interpreter (192), a module of computer program instructions that processes VoiceXML grammars. VoiceXML input to VoiceXML interpreter (192) may originate, for example, from VoiceXML clients running remotely on speech-enabled devices, from X+V clients running remotely on speech-enabled devices, from SALT clients running on speech-enabled devices, from Java client applications running remotely on multimedia devices, and so on. In this example, VoiceXML interpreter (192) interprets and executes VoiceXML segments representing voice dialog instructions received from remote speech-enabled devices and provided to VoiceXML interpreter (192) through voice server application (188).

A speech-enabled application (195 on FIG. 3) in a thin-client architecture may provide voice dialog instructions, VoiceXML segments, VoiceXML <form> elements, and the like, to VoiceXML interpreter (149) through data communications across a network with such a speech-enabled application. The voice dialog instructions include one or more grammars, data input elements, event handlers, and so on, that advise the VoiceXML interpreter how to administer voice input from a user and voice prompts and responses to be presented to a user. The VoiceXML interpreter administers such dialogs by processing the dialog instructions sequentially in accordance with a VoiceXML Form Interpretation Algorithm (‘FIA’) (193). The VoiceXML interpreter interprets VoiceXML dialogs provided to the VoiceXML interpreter by a speech-enabled application.

As mentioned above, a Form Interpretation Algorithm (‘FIA’) drives the interaction between the user and a speech-enabled application. The FIA is generally responsible for selecting and playing one or more speech prompts, collecting a user input, either a response that fills in one or more input items, or a throwing of some event, and interpreting actions that pertained to the newly filled-in input items. The FIA also handles speech-enabled application initialization, grammar activation and deactivation, entering and leaving forms with matching utterances and many other tasks. The FIA also maintains an internal prompt counter that is increased with each attempt to provoke a response from a user. That is, with each failed attempt to prompt a matching speech response from a user an internal prompt counter is incremented.

Also stored in RAM (168) is an operating system (154). Operating systems useful in voice servers according to embodiments of the present invention include UNIX™, Linux™, Microsoft NT™, AIX™, IBM's i5/OS™, and others as will occur to those of skill in the art. Operating system (154), voice server application (188), VoiceXML interpreter (192), ASR engine (150), JVM (102), and TTS Engine (194) in the example of FIG. 4 are shown in RAM (168), but many components of such software typically are stored in non-volatile memory also, for example, on a disk drive (170).

Voice server (151) of FIG. 4 includes bus adapter (158), a computer hardware component that contains drive electronics for high speed buses, the front side bus (162), the video bus (164), and the memory bus (166), as well as drive electronics for the slower expansion bus (160). Examples of bus adapters useful in voice servers according to embodiments of the present invention include the Intel Northbridge, the Intel Memory Controller Hub, the Intel Southbridge, and the Intel I/O Controller Hub. Examples of expansion buses useful in voice servers according to embodiments of the present invention include Industry Standard Architecture (‘ISA’) buses and Peripheral Component Interconnect (‘PCI’) buses.

Voice server (151) of FIG. 4 includes disk drive adapter (172) coupled through expansion bus (160) and bus adapter (158) to processor (156) and other components of the voice server (151). Disk drive adapter (172) connects non-volatile data storage to the voice server (151) in the form of disk drive (170). Disk drive adapters useful in voice servers include Integrated Drive Electronics (‘IDE’) adapters, Small Computer System Interface (‘SCSI’) adapters, and others as will occur to those of skill in the art. In addition, non-volatile computer memory may be implemented for a voice server as an optical disk drive, electrically erasable programmable read-only memory (so-called ‘EEPROM’ or ‘Flash’ memory), RAM drives, and so on, as will occur to those of skill in the art.

The example voice server of FIG. 4 includes one or more input/output (‘I/O’) adapters (178). I/O adapters in voice servers implement user-oriented input/output through, for example, software drivers and computer hardware for controlling output to display devices such as computer display screens, as well as user input from user input devices (181) such as keyboards and mice. The example voice server of FIG. 4 includes a video adapter (209), which is an example of an I/O adapter specially designed for graphic output to a display device (180) such as a display screen or computer monitor. Video adapter (209) is connected to processor (156) through a high-speed video bus (164), bus adapter (158), and the front side bus (162), which is also a high-speed bus.

The example voice server (151) of FIG. 4 includes a communications adapter (167) for data communications with other computers (182) and for data communications with a data communications network (100). Such data communications may be carried out serially through RS-232 connections, through external buses such as a Universal Serial Bus (‘USB’), through data communications data communications networks such as IP data communications networks, and in other ways as will occur to those of skill in the art. Communications adapters implement the hardware level of data communications through which one computer sends data communications to another computer, directly or through a data communications network. Examples of communications adapters useful for embodiments of the present invention include modems for wired dial-up communications, Ethernet (IEEE 802.3) adapters for wired data communications network communications, and 802.11 adapters for wireless data communications network communications.

For further explanation, FIG. 5 sets forth a block diagram of automated computing machinery comprising an example of a computer useful as a triple server (157) for configuring computer memory according to embodiments of the present invention. The triple server (157) of FIG. 5 includes at least one computer processor (156) or ‘CPU’ as well as random access memory (168) (‘RAM’) which is connected through a high-speed memory bus (166) and bus adapter (158) to processor (156) and to other components of the triple server. The processor is connected through a video bus (164) to a video adapter (209) and a computer display (180). The processor is connected through an expansion bus (160) to a communications adapter (167), an I/O adapter (178), and a disk drive adapter (172). The processor is connected to a speech-enabled laptop (126) through data communications network (100) and wireless connection (118). Disposed in RAM is an operating system (154).

Also disposed in RAM are a triple server application program (297), a semantic query engine (298), a general language triple store (323), a jargon triple store (325), a triple parser/serializer (294), a triple converter (292), and one or more triple files (290). The triple server application program (297) accepts, through network (100) from speech-enabled devices such as laptop (126), semantic queries that it passes to the semantic query engine (298) for execution against the triple stores (323, 325).

The triple parser/serializer (294) administers the transfer of triples between triple stores and various forms of disk storage. The triple parser/serializer (294) accepts as inputs the contents of triple stores and serializes them for output as triple files (290), tables, relational database records, spreadsheets, or the like, for long-term storage in non-volatile memory, such as, for example, a hard disk (170). The triple parser/serializer (294) accepts triple files (290) as inputs and outputs parsed triples into triple stores. In many embodiments, when the triple parser/serializer (294) accepts triple files (290) as inputs and outputs parsed triples into triple stores, the triple parser/serializer stores the output triple stores into contiguous segments of memory. Contiguous storage can be effected in the C programming language by a call to the malloc( ) function. Contiguous storage can be effected by the Python buffer protocol. Contiguous storage can be effected in other ways as will occur to those of skill in the art, and all such ways are within the scope of the present invention. In many embodiments, both triple stores (323, 325) would be stored in one or two segments of contiguous memory.

Contiguous memory is explained in more detail with reference to FIG. 6. FIG. 6 sets forth a block diagram of a computer memory system that includes a computer processor composed of various registers (190) executing a speech-enabled application program (195). The application and the registers of the processor operate with memory addresses (700) disposed in virtual memory (708). The contents of virtual memory are backed up with physical storage in an on-processor cache (186), RAM (168), and disk (170). The contents of the cache are organized in cache lines (702). Memory in RAM is organized in pages (712). Memory on disk is organized in frames (706). A memory management unit (“MMU”) (184) translates virtual memory addresses into physical memory locations and moves contents of memory from physical storage to and from processor registers. In accessing physical memory, the MMU always looks first in the cache. A failure to find content in the cache is termed a cache miss (714). Upon a cache miss, the MMU find sought content in RAM (168) and moves it into the cache. Failing to find sought content in RAM, a failure termed a page fault (716), the MMU looks all the way out to the page frames on disk, moves content into RAM and then into cache.

Here is the challenge addressed by the use of contiguous memory. Cache access takes 10 nanoseconds. RAM access takes 100 nanoseconds. Disk access takes 10,000,000 nanoseconds. Those numbers are not intuitive. People don't experience time in nanoseconds. Look at it in more familiar terms. If cache access is viewed as taking one minute, then RAM access takes 10 minutes, and disk access for the same data takes two years. Triples scattered across virtual memory addresses risk being stored in multiple page frames. Triples stored near one another in a contiguous memory segment are much more likely to be stored in a small number of page frames.

Suppose a jargon is composed of 500-word families each of which includes three words so that the entire jargon is expressed in 1500 words each of which on average is composed of 10 bytes of storage for a total for the jargon of 15 kilobytes of storage. Some computer systems today support memory page sizes of a megabyte or more. Such a jargon can be stored in a single memory page, and, once that page is in RAM, operation of the jargon can proceed with no risk of page faults at all. Even if contiguous storage for such a jargon fell across a page boundary, the entire jargon can be loaded with only two page faults, and, after it is loaded into RAM, it can be operated with zero page faults going forward. Cache misses would still be required to load the contents into cache, but, except for the first one or two misses, none of the others would risk a page fault. The inventors estimate that after a short period of operation, the cache miss rate would be less than one percent. That is, when a jargon is disposed in contiguous memory according to embodiments of the present invention, memory access times generally will approximate cache access times, just a few nanoseconds, for more than 99% of memory access.

For further explanation, FIG. 7 sets forth a functional block diagram of example apparatus for configuring computer memory in a thick-client architecture according to embodiments of the present invention. A thick-client architecture is a client-server architecture in which all or most of the functionality required to administer configuring computer memory with triples of a description logic is supported directly on client-side speech-enabled devices rather than on servers. Servers are used for backup and synchronization rather than speech recognition or semantic queries. A thick client requires resources, processor power and storage, possibly not always available on a small device such as a smartwatch. In a thick client with sufficient data processing resources, however, all pertinent functionality, queries, triples, speech, are typically immediately and fully useful, regardless of network availability.

The thick-client speech-enabled device in the example of FIG. 7 is automated computer machinery that includes a processor (156), RAM (168), data buses (162, 164, 166, 160), video (180, 209), data communications (167), I/O (178), and disk storage (170). Disposed in RAM are a speech-enabled application program (195), a semantic query engine (298), a general language triple store (323), a jargon triple store (325), a triple parser/serializer (294), a triple converter (292), and one or more triple files (290). The speech-enabled application (195) accepts from user input semantic queries that it passes to the semantic query engine (298) for execution against the triple stores (323, 325). All pertinent triples are available in local RAM. All queries succeed or fail based on local storage alone. No queries are ever forwarded to the triple server (157). The triple server (157) provides long-term backup and synchronization functions when multiple client-side devices share the contents of triple stores, but, for any particular query, all responsive triples are available directly on the client side.

The triple parser/serializer (294) administers the transfer of triples between triple stores and disk storage (170), and disk storage is available directly on the thick-client (152) rather than across a network on a server. The triple parser/serializer (294) accepts as inputs the contents of triple stores and serializes them for output as triple files (290), tables, relational database records, spreadsheets, or the like, for long-term storage in non-volatile memory, such as, for example, a hard disk (170). The triple parser/serializer (294) accepts triple files (290) as inputs and outputs parsed triples into triple stores. In many embodiments, when the triple parser/serializer (294) accepts triple files (290) as inputs and outputs parsed triples into triple stores, the triple parser/serializer stores the output triple stores into contiguous segments of memory.

The speech-engine engine (153) is a full-service NLP-SR engine that includes natural language processing (155), speech recognition (150), a grammar (104), a lexicon (106), a model (108), and text-to-speech processing (194), all as described in more detail above with regard to FIG. 3. The thick-client speech-enabled device (152) has no need to reach across a network for speech-related processing. Full speech enablement is available directly on the speech-enabled device itself.

For further explanation, FIG. 8 sets forth a flow chart illustrating an example method of configuring computer memory according to embodiments of the present invention. The functions of the method of FIG. 8 are implemented with or disposed upon some combination of a speech-enabled device, a voice server (151), and a triple server (157). That is, for example, the NLP-SR engine (153) can be disposed upon the voice server (151) in a thin-client architecture or upon the speech-enabled device (152) in a thick-client architecture. So the question exactly where any particular function occurs depends upon the architecture, although all such elements are computers—and they all include computer memory that can configured according to embodiments.

The method of FIG. 8 includes recognizing (302), by a natural language processing speech recognition (“NLP-SR”) engine (153) into digitized speech (508), speech from a conversation (313). The method also includes parsing (304) a word (509) of digitized speech (508) from the conversation (313) into a triple (752) of a description logic (306). In many embodiments of methods like the one illustrated here, the description logic (306) is a member of a family of formal knowledge representation languages in which a query of the logic is decidable.

In typical embodiments, both recognizing (302) speech and parsing (304) words into triples are carried out by an NLP-SR engine (153). The NLP-SR engine inputs, optionally at least, the entire conversation (313) and presents to the parsing function (304) a stream of digitized speech (508). The parsing function processes a word (509), hands a triple off to a query engine (298) for further processing, and then loops (312) back to parse the next word in the stream of digitized speech.

The NLP-SR engine hands off a parsed triple (752) to a semantic query engine (298). The semantic query engine determines whether the parsed triple is recorded (308) in a general language triple store (323) in computer memory (168), and, if it is not (314), the query engine then determines whether the parsed triple is recorded (316) in a jargon triple store (325) in the computer memory.

If the parsed triple is recorded in neither the general language triple store nor the jargon triple store (314, 320), then a speech-enabled application (195) records (322) the parsed triple in the jargon triple store (325). After recording (322), the method loops (312) back to parse (304) the next word (509) in the stream of digitized speech (508). If the parsed triple is already stored in either a general language triple store (310) or a jargon triple store (318), then the method loops (312) directly back to parsing (304) a next word (509) without recording (322).

The general language triple store (323) is composed of structured definitions of words not special to any particular knowledge domain, in which each structured definition of the general language store is composed of a triple of the description logic. The jargon triple store (325) is composed of structured definitions of words that are special to a particular knowledge domain, where each structured definition of the jargon triple store is composed of a triple of the description logic. Both triple stores (323, 325) in embodiments can be stored in contiguous memory, either in a same segment of contiguous memory or in separate segments of contiguous memory.

And triple stores can include more than one jargon. User (128), for example, can be a tele-agent in a call center who is expected to field calls from customer in health care, law offices, and residential construction. The user needs help on the phone in three specialized terminologies, not just one. At least some embodiments, therefore, include selecting (301) among a plurality of j argon triple stores the jargon triple store (325) for use in any particular conversation. The user can simply press or click a button in a dashboard on a GUI to select among jargons. The correct jargon can be inferred from the industry specification or SIC code of the company with which the user is dealing in the dashboard, the company with whom the tele-agent is speaking. The correct jargon can be inferred from usage, asserting queries with parsed triples against multiple jargon triple stores and select the jargon triple store with the most hits. Inferring from usage may mean that the user need do nothing—the user might not even have the dashboard up on screen, or the user might even have up a dashboard at the beginning of a new conversation that is unrelated to the subject area of the new conversation.

In some embodiments, the general language triple store (323) and the jargon triple store (325) are logically-connected segments of a language-specific triple store. For further explanation, FIG. 9 sets forth a graph of a language-specific triple store in which a general language triple store (323) and two jargon triple stores are logically-connected segments of a same overall graph (201). All words (202-224) in graph (201) are subjects of triples that identify them as words of English (200). Words (202-208) are identified in triples as words of the English language generally (225). Words (210-216) are identified in triples as words of a medical jargon (226). Words (218-224) are identified in triples as words of a legal jargon (228). In embodiments, all words in the graph typically are subjects of triples with definitions. In this example, for convenience of illustration, only words (208, 210, 218) are shown with definitions (236, 244, 252).

In other embodiments, the general language triple store and the jargon triple store are implemented in separate stores and separate graphs. For further explanation, FIG. 10 sets forth separate graphs of a general language triple store (238), a medical jargon in English (240), and a legal jargon in English (228). All words (202-224) in graphs (238, 240, 242) are subjects of triples that identify them as words of English (200, 226, 228). Words (202-208) in graph (238) are identified in triples as words of the English language generally (200). Words (210-216) in graph (240) are identified in triples as words of an English medical jargon (226). Words (218-224) in graph (242) are identified in triples as words of an English legal jargon (228). In this example, all words in all three graphs are subjects of triples with definitions (230-258).

Queries against a jargon triple store in a graph like graph (201) require a clause specifying the particular jargon against which the query is issued:

Query:

SELECT ?definition WHERE { :word(210) :isawordof :medical jargon . :word(210) :has definition ?definition . }

Response: :definition(244)

Queries against a jargon triple stores in separate graphs like those shown in FIG. 10 do not require a clause specifying the particular jargon against which the query is issued:

Query on graph (240):

SELECT ?definition WHERE { :word(210) :has definition ?definition . }

Response: :definition(244)

For further explanation, FIG. 11 sets forth a flow chart illustrating a further example method of configuring computer memory according to embodiments of the present invention. The method of FIG. 11 is similar to the example method of FIG. 8, including as it does recognizing digitized speech (508), parsing (304) a word (509) of digitized speech (508) into a triple (752) of a description logic (306), determining whether the parsed triple is recorded (308) in a general language triple store (323), and, if it is not (314), then determining whether the parsed triple is recorded (316) in a jargon triple store (325) in the computer memory, recording (322) a parsed triple in the jargon triple store (325), and looping (312) back to parsing (304) the next word (509) in a stream of digitized speech (508).

The method of FIG. 11 differs from that of FIG. 8 by including two types of queries, one type (339, 340) that asks whether a triple is in a store, and another type that queries for definitions. In the method of FIG. 11, determining (308) whether a parsed triple (752) is recorded in a general language triple store (323) is carried out by asserting (324) against the general language triple store a query (339) based upon the parsed triple. Similarly, determining (316) whether a parsed triple (752) is recorded in a jargon triple store (325) is carried out by asserting (326) against the jargon triple store a query (340) based upon the parsed triple.

These queries (339, 340) ask only whether the parsed triple is presently recorded in a triple store. They do not ask for definitions or inferences. These queries (339, 340) are semantic queries that take a form similar to the data they query. Take for example the connected triples describing Bob and the Mona Lisa, again expressed here in an abstract syntax with (subject predicate object) separated by spaces:

(Bob isA person) (Bob isAFriendOf Alice) (Bob isBornOn “the 4^(th) of July 1990”) (Bob isInterestedIn “the Mona Lisa”) (“the Mona Lisa” wasCreatedBy “Leonardo da Vinci”) (“the video ‘La Joconde à Washington’” isAbout “the Mona Lisa”)

In an example where the parsed triple asserts (Bob isAFriendOf Mike), then this query:

-   -   ASK {:Bob :isAFriendOF :Mike.}

returns “No.” The ASK syntax is fashioned after SPARQL, and it reports only success or failure in matching the query, nothing else. In an example where the parsed triple asserts (Bob isAFriendOf Alice), then this query:

-   -   ASK {:Bob :isAFriendOF :Alice.}

returns “Yes.” Thus, the queries (339, 340) ask only whether the parsed triple is presently recorded in one of the triple stores (323, 325).

The method of FIG. 11 also includes executing (338) by a query engine (298) against the jargon triple store (325) a semantic query (341) for a definition of a term of jargon recorded in the jargon triple store. The semantic query is, for example, received (344) in the query engine through an element of a graphical user interface (110)—or, for a further example, through a speech-enabled user interface such as a microphone (176) and VoiceXML dialog (522). The query engine (298) retrieves (343) and displays (348, 350) the results (342) of the semantic query (341) either back through the element of the graphical user interface (110) or through the speech-enabled user interface (522, 177).

Query (341) is different from the queries (339, 340) discussed just above. Query (341) does not ask merely whether data is in a store, query (341) asks for the data itself to be returned. Thus, again with reference to Bob and the Mona Lisa, this query, which requests predicates and objects from all triples in which Bob is the subject:

SELECT ?predicate ?object WHERE { :Bob :?predicate :?subject .}

returns this:

:isA :person :isAFriendOf :Alice :isBornOn :“the 4^(th) of July 1990” :isInterestedIn :“the Mona Lisa”)

This query:

SELECT ?predicate ?object WHERE { :“the Mona Lisa” :?predicate :?subject .}

returns this:

-   -   :wasCreatedBy :“Leonardo da Vinci”

And this query:

SELECT ?subject ?predicate ?object WHERE { :?subject :?predicate :?“the Mona Lisa” .}

returns this:

-   -   :“the video ‘La Joconde à Washington’”:isAbout :“the Mona Lisa”

For further explanation, FIG. 12 sets forth a flow chart illustrating a further example method of configuring computer memory according to embodiments of the present invention. The method of FIG. 12 is similar to the example method of FIG. 8, including as it does recognizing digitized speech (508), parsing (304) a word (509) of digitized speech into a triple (752) of a description logic, determining whether the parsed triple is recorded (308) in a general language triple store (323), and, if it is not (314), then determining whether the parsed triple is recorded (316) in a jargon triple store (325) in the computer memory, recording (322) a parsed triple in the jargon triple store (325), and looping (312) back to parsing (304) the next word (509) in a stream of digitized speech (508).

The method of FIG. 12 differs from that of FIG. 8 by including an additional confirmation (328) that a parsed triple (752) actually is to be recorded in a jargon triple store (325). In the example of FIG. 12, a parsed triple (752) has been determined not recorded (314) in a general language triple store and not recorded (320) in the pertinent jargon triple store. Before recording (322) the parsed triple in the jargon triple store, the method of FIG. 12 confirms (328) that the parsed triple should be recorded in the jargon triple store. If the parsed triple fails confirmation (330), the method proceeds by looping (312) back to parsing (304) the next word in the stream of digitized speech (304).

Consider a use case in which a user who is a tele-agent in a call center is discussing with a customer a prospective sale of residential construction materials. The NLP-SR engine typically provides as digitized speech words organized in sentences and identified as parts of speech. The parsing process then can, for example, take the subject, the verb, and a direct object from a sentence and parse them into a triple with a subject, predicate, and object. From this sentence, for example, “Doors are construction materials,” the parser can produce (door isA constructionMateral), and pass that triple along to the rest of the process as a candidate parsed triple (752) for inclusion in the jargon store (325). But these assertions regarding doors are more difficult:

-   -   A door is a gateway in time.     -   Doors are member of a rock band.     -   A door is a figure of speech in The Doors Of Perception by         Aldous Huxley.

It is hard to tell why such results originate in a conversation about residential construction. Perhaps the speech engine made a mistake. Perhaps the users wandered off topic. All of which makes little difference. The point is that the parser will produce triples from these words that are not pertinent to residential construction. Such triples are likely not in the jargon triple store, but also such triples may not be in the general language triple store. In which case, such triples become candidates for inclusion in the jargon triple store despite the fact that such triples do not really belong in the jargon triple store.

The confirmation process (328) can query a technical dictionary (336) of construction terms. The technical dictionary is unstructured text, no semantics, no triples, but it does contain searchable definitions. If “gateway in time,” “rock band,” or “The Doors Of Perception” do not appear in definitions of doors, the confirmation process can conclude (330) that certain triples do not belong (330) in the jargon triple store (325) and loop (312) to continue processing. The confirmation process (328) can query a user (334), through, for example, a GUI interface or a speech interface, present a candidate parsed triple, and ask whether to add it to the jargon triple store. If the user confirms (332), then record (322) and loop (312). If the user does not confirm (330), loop (312) without recording (322).

It will be understood from the foregoing description that modifications and changes may be made in various embodiments of the present invention without departing from its true spirit. The descriptions in this specification are for purposes of illustration only and are not to be construed in a limiting sense. The scope of the present invention is limited only by the language of the following claims. 

What is claimed is:
 1. A method of configuring computer memory in a computer system, the method comprising: parsing a word of digitized speech from a conversation into a triple of a description logic; determining whether the parsed triple is recorded in a general language triple store of the computer memory; determining whether the parsed triple is recorded in a jargon triple store of the computer memory; if the parsed triple is recorded in neither the general language triple store nor the jargon triple store, recording the parsed triple in the jargon triple store; executing by a query engine of the computer system against the jargon triple store a semantic query for a definition of a term of jargon recorded in the jargon triple store, the semantic query received in the query engine through an element of a graphical user interface; and displaying results of the semantic query through the element of the graphical user interface.
 2. The method of claim 1 further comprising recognizing, by a natural language processing speech recognition (“NLP-SR”) engine into the digitized speech, speech from the conversation.
 3. The method of claim 1 wherein the description logic is a member of a family of formal knowledge representation languages in which a query of the logic is decidable.
 4. The method of claim 1 wherein: the general language triple store comprises structured definitions of words not special to any particular knowledge domain, each structured definition of the general language triple store comprising a triple of the description logic; and the jargon triple store comprises structured definitions of words that are special to a particular knowledge domain, each structured definition of the jargon triple store comprising a triple of the description logic.
 5. The method of claim 1 wherein the general language triple store and the jargon triple store are logically-connected segments of a language-specific triple store.
 6. The method of claim 1 further comprising selecting the jargon triple store from among a plurality of jargon triple stores.
 7. The method of claim 1 wherein the jargon triple store of the computer memory further comprises the jargon triple store disposed within a segment of contiguous computer memory.
 8. The method of claim 1 wherein: determining whether the parsed triple is recorded in a general language triple store comprises asserting against the general language triple store a query comprising the parsed triple; and determining whether the parsed triple is recorded in a jargon triple store comprises asserting against the jargon triple store a query comprising the parsed triple.
 9. The method of claim 1 further comprising: executing by a query engine of the computer system against the jargon triple store a semantic query for a definition of a term of jargon recorded in the jargon triple store, the semantic query received in the query engine through a speech-enabled user interface; and displaying results of the semantic query through the speech-enabled user interface.
 10. A computer system comprising: computer memory operatively coupled to a computer processor; a general language triple store of the computer memory, the general language triple store comprising triples of a description logic; a jargon triple store of the computer memory, the jargon triple store comprising triples of the description logic; a parsed triple of the description logic comprising a word of digitized speech parsed from a conversation into the parsed triple; and a query engine, a module of automated computing machinery, configured to function by executing against the jargon triple store a semantic query for a definition of a term of jargon recorded in the jargon triple store, the semantic query received in the query engine through an element of a graphical user interface, and displaying results of the semantic query through the element of the graphical user interface; wherein the computer processor is configured to function by determining whether the parsed triple is recorded in the general language triple store and whether the parsed triple is recorded in the jargon triple store, and, if the parsed triple is recorded in neither the general language triple store nor the jargon triple store, recording the parsed triple in the jargon triple store.
 11. The computer system of claim 10 further comprising a natural language processing speech recognition engine configured to function by recognizing, into words of digitized speech, speech from the conversation.
 12. The computer system of claim 10 wherein the description logic is a member of a family of formal knowledge representation languages in which a query of the logic is decidable.
 13. The computer system of claim 10 wherein: the general language triple store comprises structured definitions of words not special to any particular knowledge domain, each structured definition of the general language triple store comprising a triple of the description logic; and the jargon triple store comprises structured definitions of words that are special to a particular knowledge domain, each structured definition of the jargon triple store comprising a triple of the description logic.
 14. The computer system of claim 10 wherein the general language triple store and the jargon triple store are logically connected segments of a language-specific triple store.
 15. The computer system of claim 10 wherein the jargon triple store comprises a jargon triple store selected from among a plurality of jargon triple stores.
 16. The computer system of claim 10 wherein the jargon triple store of the computer memory comprises the jargon triple store disposed within a segment of contiguous computer memory.
 17. The computer system of claim 10 wherein: determining whether the parsed triple is recorded in the general language triple store comprises asserting against the general language triple store a query comprising the parsed triple; and determining whether the parsed triple is recorded in the jargon triple store comprises asserting against the jargon triple store a query comprising the parsed triple.
 18. The computer system of claim 10 further comprising a query engine, a module of automated computing machinery, configured to function by: executing against the jargon triple store a semantic query for a definition of a term of jargon recorded in the jargon triple store, the semantic query received in the query engine through a speech-enabled user interface; and displaying results of the semantic query through the speech-enabled user interface.
 19. A method of configuring computer memory in a computer system, the method comprising: parsing a word of digitized speech from a conversation into a triple of a description logic; determining whether the parsed triple is recorded in a general language triple store of the computer memory; determining whether the parsed triple is recorded in a jargon triple store of the computer memory; if the parsed triple is recorded in neither the general language triple store nor the jargon triple store, recording the parsed triple in the jargon triple store; executing by a query engine of the computer system against the jargon triple store a semantic query for a definition of a term of jargon recorded in the jargon triple store, the semantic query received in the query engine through a speech-enabled user interface; and displaying results of the semantic query through the speech-enabled user interface.
 20. The method of claim 19 further comprising recognizing, by a natural language processing speech recognition (“NLP-SR”) engine into the digitized speech, speech from the conversation.
 21. The method of claim 19 wherein the description logic is a member of a family of formal knowledge representation languages in which a query of the logic is decidable.
 22. The method of claim 19 wherein: the general language triple store comprises structured definitions of words not special to any particular knowledge domain, each structured definition of the general language triple store comprising a triple of the description logic; and the jargon triple store comprises structured definitions of words that are special to a particular knowledge domain, each structured definition of the jargon triple store comprising a triple of the description logic.
 23. The method of claim 19 wherein the general language triple store and the jargon triple store are logically-connected segments of a language-specific triple store.
 24. The method of claim 19 further comprising selecting the jargon triple store from among a plurality of jargon triple stores.
 25. The method of claim 19 wherein the jargon triple store of the computer memory further comprises the jargon triple store disposed within a segment of contiguous computer memory.
 26. The method of claim 19 wherein: determining whether the parsed triple is recorded in a general language triple store comprises asserting against the general language triple store a query comprising the parsed triple; and determining whether the parsed triple is recorded in a jargon triple store comprises asserting against the jargon triple store a query comprising the parsed triple.
 27. A computer system comprising: computer memory operatively coupled to a computer processor; a general language triple store of the computer memory, the general language triple store comprising triples of a description logic; a jargon triple store of the computer memory, the jargon triple store comprising triples of the description logic; and a parsed triple of the description logic comprising a word of digitized speech parsed from a conversation into the parsed triple; and a query engine, a module of automated computing machinery, configured to function by executing against the jargon triple store a semantic query for a definition of a term of jargon recorded in the jargon triple store, the semantic query received in the query engine through a speech-enabled user interface, and displaying results of the semantic query through the speech-enabled user interface; wherein the computer processor is configured to function by determining whether the parsed triple is recorded in the general language triple store and whether the parsed triple is recorded in the jargon triple store, and, if the parsed triple is recorded in neither the general language triple store nor the jargon triple store, recording the parsed triple in the jargon triple store.
 28. The computer system of claim 27 further comprising a natural language processing speech recognition engine configured to function by recognizing, into words of digitized speech, speech from the conversation.
 29. The computer system of claim 27 wherein the description logic is a member of a family of formal knowledge representation languages in which a query of the logic is decidable.
 30. The computer system of claim 27 wherein: the general language triple store comprises structured definitions of words not special to any particular knowledge domain, each structured definition of the general language triple store comprising a triple of the description logic; and the jargon triple store comprises structured definitions of words that are special to a particular knowledge domain, each structured definition of the jargon triple store comprising a triple of the description logic.
 31. The computer system of claim 27 wherein the general language triple store and the jargon triple store are logically connected segments of a language-specific triple store.
 32. The computer system of claim 27 wherein the jargon triple store comprises a jargon triple store selected from among a plurality of jargon triple stores.
 33. The computer system of claim 27 wherein the jargon triple store of the computer memory comprises the jargon triple store disposed within a segment of contiguous computer memory.
 34. The computer system of claim 27 wherein: determining whether the parsed triple is recorded in the general language triple store comprises asserting against the general language triple store a query comprising the parsed triple; and determining whether the parsed triple is recorded in the jargon triple store comprises asserting against the jargon triple store a query comprising the parsed triple. 